home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume4 / rolodex / part2 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  59.4 KB
  1. From: ihnp4!think!massar (JP Massar)
  2. Subject: rolodex database program -- part 2 of 3
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 4, Issue 28
  7. Submitted by: ihnp4!think!massar (JP Massar)
  8.  
  9. #! /bin/sh
  10. # This is a shell archive, meaning:
  11. # 1. Remove everything above the #! /bin/sh line.
  12. # 2. Save the resulting text in a file.
  13. # 3. Execute the file with /bin/sh (not csh) to create the files:
  14. #    choices.h
  15. #    clear.c
  16. #    datadef.h
  17. #    io.c
  18. #    menuaux.c
  19. #    operations.c
  20. #    options.c
  21. #    rlist.c
  22. #    rolo.c
  23. #    rolodefs.h
  24. #    rolofiles.h
  25. #    search.c
  26. #    update.c
  27. # This archive created: Thu Mar 13 18:29:52 1986
  28. export PATH; PATH=/bin:$PATH
  29. echo shar: extracting "'choices.h'" '(685 characters)'
  30. if test -f 'choices.h'
  31. then
  32.     echo shar: will not over-write existing file "'choices.h'"
  33. else
  34. cat << \SHAR_EOF > 'choices.h'
  35. typedef enum { P_CONTINUE, P_NEXT_PERSON, P_ABORT, P_HELP } P_Choices;
  36.  
  37. typedef enum { 
  38.         
  39.         M_SEARCH_BY_OTHER, M_SEARCH_BY_NAME, M_PRINT_TO_LASER_PRINTER,
  40.         M_HELP, M_EXIT, M_PERUSE, M_SAVE, M_ADD
  41.  
  42.       } Main_Choices;
  43.  
  44. typedef enum { 
  45.  
  46.         A_ABORT_ADD, A_BACKUP, A_FILL_IN_REST,
  47.         A_ABORT_ROLO, A_HELP, A_NO_DATA
  48.  
  49.       } Add_Choices;
  50.  
  51. typedef enum { 
  52.         
  53.         E_ABORT, E_UPDATE, E_DELETE, E_CONTINUE, E_PREV, E_HELP, E_SCAN
  54.         
  55.       } E_Choices;
  56.  
  57. typedef enum { U_ABORT, U_HELP, U_END_UPDATE } U_Choices;
  58.  
  59. typedef enum { S_ABORT, S_HELP, S_SCAN_ONE_BY_ONE } S_Choices;
  60.  
  61. typedef enum { O_ABORT, O_HELP, O_BACKUP, O_DONE_OTHERS } O_Choices;
  62. SHAR_EOF
  63. if test 685 -ne "`wc -c < 'choices.h'`"
  64. then
  65.     echo shar: error transmitting "'choices.h'" '(should have been 685 characters)'
  66. fi
  67. fi
  68. echo shar: extracting "'clear.c'" '(930 characters)'
  69. if test -f 'clear.c'
  70. then
  71.     echo shar: will not over-write existing file "'clear.c'"
  72. else
  73. cat << \SHAR_EOF > 'clear.c'
  74. #include <stdio.h>
  75. #ifdef TERMINFO
  76. #include <term.h>
  77. #endif
  78. #undef putchar
  79.  
  80. int putchar();
  81. static int ok_to_clear;
  82.  
  83. #ifdef TERMCAP
  84. static char clear_screen[128] = 0;
  85. static int lines;
  86. #endif
  87.  
  88. clearinit ()
  89. {
  90. #ifdef TERMINFO
  91.   int i;        
  92.   setupterm(getenv("TERM"),1,&i);
  93.   ok_to_clear = (i == 1) ? 1 : 0;
  94.   if (i != 1) {
  95.      fprintf(stderr,"Warning: Terminal type unknown\n");
  96.   }
  97.   return (i == 1) ? 0 : -1;
  98. #endif
  99. #ifdef TERMCAP
  100.   char tc[1024];
  101.   char *ptr = clear_screen;
  102.  
  103.   if (tgetent(tc, getenv("TERM")) < 1) {
  104.     ok_to_clear = 0;
  105.     return;
  106.   }
  107.   tgetstr("cl", &ptr);
  108.   lines = tgetnum("li");
  109.   ok_to_clear = (clear_screen[0] != 0 && lines > 0);
  110.  
  111. #endif
  112. }        
  113.         
  114. clear_the_screen ()
  115. {
  116. #ifdef TERMINFO
  117.   if (!ok_to_clear) return;        
  118.   tputs(clear_screen,lines,putchar);
  119.   fflush(stdout);
  120. #endif
  121. #ifdef TERMCAP
  122.   if (!ok_to_clear) return;
  123.   tputs(clear_screen,lines,putchar);
  124.   fflush(stdout);
  125. #endif
  126. }
  127. SHAR_EOF
  128. if test 930 -ne "`wc -c < 'clear.c'`"
  129. then
  130.     echo shar: error transmitting "'clear.c'" '(should have been 930 characters)'
  131. fi
  132. fi
  133. echo shar: extracting "'datadef.h'" '(1911 characters)'
  134. if test -f 'datadef.h'
  135. then
  136.     echo shar: will not over-write existing file "'datadef.h'"
  137. else
  138. cat << \SHAR_EOF > 'datadef.h'
  139. #define ABORTSTRING "\\"
  140. #define ABORTCHAR '\\'
  141.  
  142. #define MAXMATCHES 17
  143.  
  144. #define N_BASIC_FIELDS 8
  145. #define OTHER -1
  146.  
  147. typedef enum Basic_Field {
  148.  
  149.     R_NAME = 0, R_WORK_PHONE, R_HOME_PHONE, R_COMPANY, R_WORK_ADDRESS,
  150.     R_HOME_ADDRESS, R_REMARKS, R_UPDATED
  151.  
  152.   };    
  153.     
  154. extern char *Field_Names[];  
  155.   
  156. /* A Rolodex entry */
  157.  
  158. typedef struct {
  159.  
  160.     char *basicfields[N_BASIC_FIELDS];
  161.     int n_others;
  162.     char **other_fields;
  163.  
  164.   } Rolo_Entry, *Ptr_Rolo_Entry;
  165.  
  166.   
  167. #define get_basic_rolo_field(n,x) (((x) -> basicfields)[(n)])
  168. #define get_n_others(x) ((x) -> n_others)  
  169. #define get_other_field(n,x) (((x) -> other_fields)[n])
  170.   
  171. #define set_basic_rolo_field(n,x,s) (((x) -> basicfields[(n)]) = (s))
  172. #define set_n_others(x,n) (((x) -> n_others) = (n))
  173. #define incr_n_others(x) (((x) -> n_others)++)
  174. #define set_other_field(n,x,s) ((((x) -> other_fields)[n]) = (s))
  175.  
  176. typedef struct link {
  177.  
  178.     Ptr_Rolo_Entry entry;
  179.     int matched;
  180.     struct link *prev;
  181.     struct link *next;
  182.  
  183.   } Rolo_List, *Ptr_Rolo_List;
  184.  
  185.  
  186. #define get_next_link(x) ((x) -> next)
  187. #define get_prev_link(x) ((x) -> prev)
  188. #define get_entry(x)     ((x) -> entry)
  189. #define get_matched(x) ((x) -> matched)
  190.  
  191. #define set_next_link(x,y) (((x) -> next) = (y))
  192. #define set_prev_link(x,y) (((x) -> prev) = (y))
  193. #define set_entry(x,y) (((x) -> entry) = (y))
  194. #define set_matched(x) (((x) -> matched) = 1)
  195. #define unset_matched(x) (((x) -> matched) = 0);
  196.  
  197. extern Ptr_Rolo_List Begin_Rlist;
  198. extern Ptr_Rolo_List End_Rlist;
  199.  
  200. #define MAXLINELEN 80
  201. #define DIRPATHLEN 100
  202.  
  203. extern int changed;
  204. extern int reorder_file;
  205. extern int rololocked;
  206.  
  207. extern char *rolo_emalloc();
  208. extern char *malloc();
  209. extern Ptr_Rolo_List new_link_with_entry();
  210. extern char *copystr();
  211. extern int compare_links();
  212. extern char *timestring();
  213. extern char *homedir(), *libdir();
  214. extern char *getenv();
  215. extern char *ctime();
  216. extern char *select_search_string();
  217. extern int in_search_mode;
  218. SHAR_EOF
  219. if test 1911 -ne "`wc -c < 'datadef.h'`"
  220. then
  221.     echo shar: error transmitting "'datadef.h'" '(should have been 1911 characters)'
  222. fi
  223. fi
  224. echo shar: extracting "'io.c'" '(8455 characters)'
  225. if test -f 'io.c'
  226. then
  227.     echo shar: will not over-write existing file "'io.c'"
  228. else
  229. cat << \SHAR_EOF > 'io.c'
  230. #include <stdio.h>
  231. #include <sys/types.h>
  232. #include <sys/stat.h>
  233. #include <sys/file.h>
  234. #include <ctype.h>
  235.  
  236. #include "sys5.h"
  237.  
  238. #ifdef TMC
  239. #include <ctools.h>
  240. #else
  241. #include "ctools.h"
  242. #endif
  243.  
  244. #include "datadef.h"
  245. #include "rolofiles.h"
  246.  
  247.  
  248. char *Field_Names[N_BASIC_FIELDS] = {
  249.         
  250.         "Name: ", "Work Phone: ", "Home Phone: ", "Company: ",
  251.         "Work Address: ", "Home Address: ", "Remarks: ", "Date Updated: "
  252.         
  253.      };
  254.  
  255. Ptr_Rolo_List Begin_Rlist = 0;
  256. Ptr_Rolo_List End_Rlist = 0;
  257. Ptr_Rolo_List Current_Entry = 0;
  258.  
  259. static char *rolofiledata;
  260.  
  261. read_rolodex (fd) int fd;
  262.  
  263. {
  264.   struct stat statdata;
  265.   int filesize,i,j,k,start_of_others,warning_given;
  266.   Ptr_Rolo_Entry newentry,oldentry,currententry;
  267.   Ptr_Rolo_List newlink,rptr;
  268.   char *next_field,*next_other,*oldname,*currentname;
  269.   char **other_pointers;
  270.   int n_entries = 0;
  271.   
  272.   /* find out how many bytes are in the file */
  273.   
  274.   fstat(fd,&statdata);
  275.   if ((filesize = statdata.st_size) == 0) {
  276.      return(0);
  277.   }
  278.  
  279.   /* create an array of characters that big */
  280.   
  281.   rolofiledata = rolo_emalloc(filesize);
  282.  
  283.   /* read them all in at once for efficiency */
  284.   
  285.   if (filesize != read(fd,rolofiledata,filesize)) {
  286.      fprintf(stderr,"rolodex read failed\n");
  287.      exit(-1);
  288.   }
  289.  
  290.   j = 0;
  291.   
  292.   /* for each entry in the rolodex file */
  293.   
  294.   while (j < filesize) {
  295.  
  296.       n_entries++;
  297.         
  298.       /* create the link and space for the data entry */
  299.         
  300.       newlink = new_link_with_entry();
  301.       newentry = get_entry(newlink);
  302.       if (j == 0) {
  303.          Begin_Rlist = newlink;
  304.          set_prev_link(newlink,0);
  305.          set_next_link(newlink,0);
  306.       }
  307.       else {
  308.           set_next_link(End_Rlist,newlink);
  309.           set_prev_link(newlink,End_Rlist);
  310.           set_next_link(newlink,0);
  311.       }
  312.       End_Rlist = newlink;
  313.  
  314.       /* locate each required field in the character array and change */
  315.       /* the ending line feed to a null.  Insert a pointer to the */
  316.       /* beginning of the field into the data entry */
  317.  
  318.       for (i = 0; i < N_BASIC_FIELDS; i++) {
  319.           next_field = rolofiledata + j;
  320.           while (rolofiledata[j] != '\n') {
  321.             j++;
  322.           }
  323.           rolofiledata[j] = '\0';
  324.           j++;
  325.           set_basic_rolo_field(i,newentry,next_field);
  326.       }
  327.  
  328.       /* the end of an entry is indicated by two adjacent newlines */
  329.  
  330.       if (rolofiledata[j] == '\n') {
  331.          j++;
  332.          newentry -> other_fields = 0;
  333.          continue;
  334.       }
  335.  
  336.       /* there must be additional, user-inserted fields. Find out how many. */
  337.  
  338.       start_of_others = j;
  339.       while (1) {
  340.         while (rolofiledata[j] != '\n') {
  341.           j++;
  342.         }
  343.         incr_n_others(newentry);
  344.         j++;
  345.         if (rolofiledata[j] == '\n') {
  346.            j++;
  347.            break;
  348.         }
  349.      }
  350.  
  351.      /* allocate an array of character pointers to hold these fields */
  352.  
  353.      other_pointers = (char **)rolo_emalloc(get_n_others(newentry)*sizeof(char *));
  354.  
  355.      /* separate each field and insert a pointer to it in the char array */
  356.  
  357.      k = start_of_others;
  358.      for (i = 0; i < get_n_others(newentry); i++) {
  359.          next_other = rolofiledata + k;
  360.          while (rolofiledata[k] != '\n') {
  361.            k++;
  362.          }
  363.          rolofiledata[k] = '\0';
  364.          other_pointers[i] = next_other;
  365.          k++;
  366.      }
  367.  
  368.      /* insert the pointer to this character array into the data entry */
  369.  
  370.      newentry -> other_fields = other_pointers;
  371.  
  372.   }
  373.  
  374.   /* check that all the entries are in alphabetical order by name */
  375.   
  376.   warning_given = 0;
  377.   rptr = get_next_link(Begin_Rlist);
  378.   while (rptr != 0) {
  379.     if (1 == compare_links(get_prev_link(rptr),rptr)) {
  380.        if (!warning_given) fprintf(stderr,"Warning, rolodex out of order\n");
  381.        warning_given = 1;
  382.        reorder_file = 1;
  383.     }
  384.     rptr = get_next_link(rptr);
  385.   }    
  386.     
  387.   return(n_entries);
  388.   
  389. }
  390.  
  391.  
  392. write_rolo_list (fp) FILE *fp; 
  393.  
  394. /* write the entire in-core rolodex to a file */
  395.  
  396. {
  397.  
  398.   Ptr_Rolo_List rptr;
  399.   Ptr_Rolo_Entry entry;
  400.   int j;
  401.  
  402.   rptr = Begin_Rlist;
  403.  
  404.   while (rptr != 0) {
  405.     entry = get_entry(rptr);
  406.     for (j = 0; j < N_BASIC_FIELDS; j++) {
  407.         fprintf(fp,"%s\n",get_basic_rolo_field(j,entry));
  408.     }
  409.     for (j = 0; j < get_n_others(entry); j++) {
  410.         fprintf(fp,"%s\n",get_other_field(j,entry));
  411.     }
  412.     fprintf(fp,"\n");
  413.     rptr = get_next_link(rptr);
  414.   }
  415.  
  416. }
  417.  
  418.  
  419. write_rolo (fp1,fp2) FILE *fp1; FILE *fp2;
  420.  
  421. {
  422.   write_rolo_list(fp1);
  423.   write_rolo_list(fp2);
  424. }
  425.  
  426.  
  427. display_basic_field (name,value,show,up) char *name; char *value; int show,up;
  428. {
  429.   int semi = 0;        
  430.   int i;
  431.   if (all_whitespace(value) && !show) return;
  432.   printf("%-25s",name);
  433.   while (*value != '\0') {
  434.     if (*value == ';') {
  435.        while (*++value == ' '); 
  436.        putchar('\n');
  437.        for (i = 0; i < (up ? 28 : 25); i++) putchar(' ');
  438.        semi = 1;
  439.     }
  440.     else {
  441.        semi = 0;
  442.        putchar(*value++);
  443.     }
  444.   }
  445.   putchar('\n');
  446. }
  447.  
  448.  
  449. display_other_field (fieldstring) char *fieldstring;
  450. {
  451.   int already_put_sep = 0;        
  452.   int count = 0;
  453.   int i;
  454.   while (*fieldstring != '\0') {
  455.     if (*fieldstring == ';' && already_put_sep) {
  456.        while (*++fieldstring == ' ');
  457.        putchar('\n');
  458.        for (i = 0; i < 25; i++) putchar(' ');
  459.        continue;
  460.     }
  461.     putchar(*fieldstring);
  462.     count++;
  463.     if (*fieldstring == ':' && !already_put_sep) {
  464.        for (i = count; i < 24; i++) putchar(' ');
  465.        already_put_sep = 1;
  466.     }
  467.     fieldstring++;
  468.   }
  469.   putchar('\n');
  470. }
  471.  
  472.  
  473. summarize_entry_list (rlist,ss) Ptr_Rolo_List rlist; char *ss;
  474.  
  475. /* print out the Name field for each entry that is tagged as matched */
  476. /* and number each entry. */
  477.  
  478. {
  479.   int count = 1;
  480.   clear_the_screen();
  481.   printf("Entries that match '%s' :\n\n",ss);
  482.   while (rlist != 0) {
  483.     if (get_matched(rlist)) {
  484.        printf (
  485.           "%d. \t%s\n",
  486.           count++,
  487.           get_basic_rolo_field((int) R_NAME,get_entry(rlist))
  488.        );
  489.     }
  490.     rlist = get_next_link(rlist);    
  491.   }
  492.   putchar('\n');
  493. }
  494.  
  495.  
  496. display_field_names ()
  497.  
  498. /* display and number each standard field name. */
  499.  
  500. {
  501.   int j;
  502.   char *name;
  503.   clear_the_screen();
  504.   for (j = 0; j < N_BASIC_FIELDS - 1; j++) {        
  505.       name = Field_Names[j];        
  506.       printf("%d. ",j+1);
  507.       while (*name != ':') putchar(*name++);
  508.       putchar('\n');
  509.   }
  510.   printf("%d. ",N_BASIC_FIELDS);
  511.   printf("A user created item name\n\n");
  512. }  
  513.   
  514.  
  515. display_entry (entry) Ptr_Rolo_Entry entry;
  516.  
  517. {
  518.   int j,n_others;
  519.   char *string;
  520.   
  521.   clear_the_screen();
  522.   
  523.   /* display the standard fields other than Date Updated */
  524.   
  525.   for (j = 0; j < N_BASIC_FIELDS - 1; j++) {
  526.       string = get_basic_rolo_field(j,entry);
  527.       display_basic_field(Field_Names[j],string,0,0);
  528.   }        
  529.       
  530.   /* display any additional fields the user has defined for this entry */
  531.   
  532.   n_others = get_n_others(entry);
  533.   for (j = 0; j < n_others; j++) {
  534.       string = get_other_field(j,entry);
  535.       display_other_field(string);
  536.    }
  537.  
  538.    /* display the Date Updated field */
  539.    
  540.    j = N_BASIC_FIELDS - 1;
  541.    display_basic_field(Field_Names[j],get_basic_rolo_field(j,entry),0,0);
  542.    fprintf(stdout,"\n");
  543.  
  544. }
  545.  
  546.  
  547. display_entry_for_update (entry) Ptr_Rolo_Entry entry;
  548.  
  549. /* same as display_entry, except each item is numbered and the Date Updated */
  550. /* item is not displayed */
  551.  
  552. {
  553.   int j,n_others;
  554.   char *string;
  555.   int count = 1;
  556.   
  557.   clear_the_screen();
  558.   
  559.   for (j = 0; j < N_BASIC_FIELDS - 1; j++) {
  560.       string = get_basic_rolo_field(j,entry);
  561.       printf("%d. ",count++);
  562.       display_basic_field(Field_Names[j],string,1,1);
  563.   }        
  564.       
  565.   n_others = get_n_others(entry);
  566.   for (j = 0; j < n_others; j++) {
  567.       string = get_other_field(j,entry);
  568.       printf("%d. ",count++);
  569.       display_other_field(string);
  570.   }
  571.   
  572.   printf("%d. Add a new user defined field\n",count);
  573.  
  574.   fprintf(stdout,"\n");
  575.  
  576. }
  577.  
  578.  
  579. int cathelpfile (filepath,helptopic,clear) 
  580.  
  581.   char *filepath, *helptopic; 
  582.   int clear;
  583.  
  584. {
  585.   FILE *fp;          
  586.   char buffer[MAXLINELEN];
  587.   if (clear) clear_the_screen();
  588.   if (NULL == (fp = fopen(filepath,"r"))) {
  589.      if (helptopic) {
  590.         printf("No help available on %s, sorry.\n\n",helptopic); 
  591.      }
  592.      else {
  593.         fprintf(stderr,"Fatal error, can't open %s\n",filepath);
  594.         exit(-1);
  595.      }
  596.      return;
  597.   }
  598.   while (NULL != fgets(buffer,MAXLINELEN,fp)) printf("%s",buffer);  
  599.   printf("\n");
  600.   fclose(fp);
  601.   return;
  602. }
  603.  
  604.  
  605. any_char_to_continue ()
  606. {
  607.   char buffer[80];
  608.   printf("RETURN to continue: ");
  609.   fgets(buffer,80,stdin);
  610.   return;
  611. }
  612. SHAR_EOF
  613. if test 8455 -ne "`wc -c < 'io.c'`"
  614. then
  615.     echo shar: error transmitting "'io.c'" '(should have been 8455 characters)'
  616. fi
  617. fi
  618. echo shar: extracting "'menuaux.c'" '(1433 characters)'
  619. if test -f 'menuaux.c'
  620. then
  621.     echo shar: will not over-write existing file "'menuaux.c'"
  622. else
  623. cat << \SHAR_EOF > 'menuaux.c'
  624. #include <stdio.h>
  625. #include <ctype.h>
  626.  
  627. #include "sys5.h"
  628.  
  629. #ifdef TMC
  630. #include <ctools.h>
  631. #else
  632. #include "ctools.h"
  633. #endif
  634. #include "args.h"
  635. #include "menu.h"
  636.  
  637. #include "rolofiles.h"
  638. #include "rolodefs.h"
  639. #include "datadef.h"
  640.  
  641.  
  642. rolo_menu_yes_no (prompt,rtn_default,help_allowed,helpfile,subject)
  643.  
  644.   char *prompt;
  645.   int rtn_default;
  646.   int help_allowed;
  647.   char *helpfile, *subject;
  648.   
  649. {
  650.   int rval;
  651.   reask :
  652.   rval = menu_yes_no_abort_or_help (
  653.               prompt,ABORTSTRING,help_allowed,rtn_default
  654.            );
  655.   switch (rval) {
  656.     case MENU_EOF :
  657.       user_eof();
  658.       break;
  659.     case MENU_HELP : 
  660.       cathelpfile(libdir(helpfile),subject,1);
  661.       goto reask;
  662.       break;
  663.     default :
  664.       return(rval);
  665.       break;
  666.   }
  667. }
  668.   
  669.  
  670. rolo_menu_data_help_or_abort (prompt,helpfile,subject,ptr_response)
  671.  
  672.   char *prompt, *helpfile, *subject;
  673.   char **ptr_response;
  674.   
  675. { 
  676.   int rval;
  677.   reask :
  678.   rval = menu_data_help_or_abort(prompt,ABORTSTRING,ptr_response);
  679.   if (rval == MENU_EOF) user_eof();
  680.   if (rval == MENU_HELP) {
  681.      cathelpfile(libdir(helpfile),subject,1);
  682.      goto reask;
  683.   }     
  684.   return(rval);
  685. }
  686.      
  687.  
  688. rolo_menu_number_help_or_abort (prompt,low,high,ptr_ival)
  689.  
  690.   char *prompt;
  691.   int low,high,*ptr_ival;
  692.   
  693. {  
  694.   int rval;
  695.   if (MENU_EOF == (rval = menu_number_help_or_abort (
  696.                                prompt,ABORTSTRING,low,high,ptr_ival
  697.                            )))
  698.      user_eof();
  699.   return(rval);
  700. }
  701. SHAR_EOF
  702. if test 1433 -ne "`wc -c < 'menuaux.c'`"
  703. then
  704.     echo shar: error transmitting "'menuaux.c'" '(should have been 1433 characters)'
  705. fi
  706. fi
  707. echo shar: extracting "'operations.c'" '(8950 characters)'
  708. if test -f 'operations.c'
  709. then
  710.     echo shar: will not over-write existing file "'operations.c'"
  711. else
  712. cat << \SHAR_EOF > 'operations.c'
  713. #include <stdio.h>
  714. #include <ctype.h>
  715.  
  716. #include "sys5.h"
  717.  
  718. #ifdef TMC
  719. #include <ctools.h>
  720. #else
  721. #include "ctools.h"
  722. #endif
  723. #include "args.h"
  724. #include "menu.h"
  725. #include "mem.h"
  726.  
  727.  
  728. #include "rolofiles.h"
  729. #include "rolodefs.h"
  730. #include "datadef.h"
  731. #include "choices.h"
  732.  
  733. extern char *ctime();
  734.  
  735. Ptr_Rolo_List create_entry (basicdata,otherdata) char **basicdata, **otherdata;
  736. {
  737.   Ptr_Rolo_List newlink;        
  738.   Ptr_Rolo_Entry newentry;
  739.   int i,j;
  740.   newlink = new_link_with_entry();        
  741.   newentry = get_entry(newlink);
  742.   for (j = 0; j < N_BASIC_FIELDS; j++) {
  743.       set_basic_rolo_field(j,newentry,basicdata[j]);
  744.   }
  745.   j = 0;
  746.   while (otherdata[j] != 0) j++;
  747.   set_n_others(newentry,j);
  748.   if (j > 0) {
  749.      newentry -> other_fields = (char **) rolo_emalloc(j*sizeof(char *));
  750.      for (i = 0; i < j; i++) {
  751.          set_other_field(i,newentry,otherdata[i]);
  752.      }
  753.   }
  754.   else newentry -> other_fields = 0;
  755.   return(newlink);
  756. }  
  757.   
  758.  
  759. other_fields () 
  760. {
  761.   int rval;        
  762.   rval = rolo_menu_yes_no (
  763.              "Additional fields? ",DEFAULT_NO,1,
  764.              "morefieldshelp","additional fields"
  765.           );
  766.   return(rval == MENU_YES);
  767. }
  768.  
  769.  
  770. add_the_entry ()
  771. {
  772.   return(MENU_YES == rolo_menu_yes_no (
  773.               "Add new entry to rolodex? ",DEFAULT_YES,1,
  774.               "newaddhelp","adding newly entered entry"
  775.            ));
  776. }
  777.  
  778.  
  779. rolo_add () 
  780.  
  781. {
  782.   int i,j,k,rval,menuval;
  783.   long timeval;
  784.   char *response;
  785.   char *basicdata[N_BASIC_FIELDS], *otherdata[100], *datum;
  786.   Ptr_Rolo_List rlink;
  787.         
  788.   for (j = 0; j < 100; j++) otherdata[j] = 0;
  789.   for (j = 0; j < N_BASIC_FIELDS; j++) basicdata[j] = 0;
  790.   cathelpfile(libdir("addinfo"),0,1);
  791.   
  792.   /* 'k' and 'kludge' are are kludge to allow us to back up from entering */
  793.   /* user defined fields to go an correct wrong basic field information. */
  794.   
  795.   k = 0;
  796.   
  797.   kludge :
  798.   
  799.   for (j = k; j < N_BASIC_FIELDS - 1; j++) {
  800.         
  801.       redo :
  802.         
  803.       rval = menu_match (
  804.            &menuval,&response,
  805.            Field_Names[j],
  806.            0,0,0,1,5,
  807.            "\\",A_ABORT_ADD,
  808.            "^",A_BACKUP,
  809.            "!",A_FILL_IN_REST,
  810.            "?",A_HELP,
  811.            "",A_NO_DATA
  812.         );
  813.         
  814.       switch (rval) {
  815.         
  816.         case MENU_NO_MATCH :
  817.           basicdata[j] = copystr(response);
  818.           if (j == 0 && strlen(basicdata[j]) == 0) {
  819.              printf("Each entry must have a name!\n");
  820.              goto redo;
  821.           }
  822.           break;
  823.  
  824.         case MENU_MATCH :
  825.           switch (menuval) {
  826.             case A_BACKUP :
  827.               if (j == 0) return;
  828.               j--;
  829.               goto redo;
  830.               break;
  831.             case A_ABORT_ADD :
  832.               return;
  833.               break;
  834.             case A_FILL_IN_REST :
  835.               if (j == 0) {
  836.                  fprintf(stderr,"You must enter at least a name...\n");
  837.                  goto redo;
  838.               }
  839.               goto add_entry;
  840.               break;
  841.             case A_HELP :
  842.               cathelpfile(libdir("addhelp"),"adding entries",1);
  843.               any_char_to_continue();
  844.               clear_the_screen();
  845.               cathelpfile(libdir("addinfo"),0,0);
  846.               for (i = 0; i < j; i++) {
  847.                   printf("%s%s\n",Field_Names[i],basicdata[i]);
  848.               }
  849.               goto redo;
  850.               break;
  851.             case A_NO_DATA :
  852.               if (basicdata[j] != 0) basicdata[j][0] = '\0';
  853.               break;
  854.             default :
  855.               fprintf(stderr,"Impossible rval from rolo_add menu_match\n");
  856.               save_and_exit(-1);
  857.               break;
  858.           }
  859.           break;
  860.  
  861.         case MENU_EOF :
  862.           user_eof();
  863.           break;
  864.           
  865.         case MENU_ERROR :
  866.         case MENU_AMBIGUOUS :
  867.         default :
  868.           fprintf(stderr,"Impossible return from rolo_add menu_match\n");
  869.           save_and_exit(-1);
  870.           break;
  871.  
  872.       }
  873.  
  874.   }
  875.  
  876.   if (other_fields()) {
  877.      for (j = 0; j < 100; j++) {
  878.          redo_other :
  879.          rval = menu_match (
  880.               &menuval,&response,
  881.               "Enter <name>: <data> (type RETURN to quit) : ",
  882.               0,0,0,0,5,
  883.               "\\",O_ABORT,
  884.               "?",O_HELP,
  885.               "Help",O_HELP,
  886.               "^",O_BACKUP,
  887.               "",O_DONE_OTHERS
  888.            );
  889.          switch (rval) {
  890.            case MENU_MATCH :
  891.              switch (menuval) {
  892.                case O_DONE_OTHERS :
  893.                  goto add_entry;
  894.                  break;
  895.                case O_BACKUP :
  896.                  if (j == 0) {
  897.                     k = N_BASIC_FIELDS - 2;
  898.                     goto kludge;
  899.                  }
  900.                  else {
  901.                     j--;
  902.                     printf("Deleting %s\n",otherdata[j]);
  903.                     goto redo_other;
  904.                  }
  905.                  break;
  906.                case O_ABORT :
  907.                  return;
  908.                  break;
  909.                case O_HELP :
  910.                  cathelpfile(libdir("otherformathelp"),"user-item format",1);
  911.                  any_char_to_continue();
  912.                  goto redo_other;
  913.               }   
  914.              break;
  915.            case MENU_NO_MATCH :
  916.              if (0 == index(response,':')) {
  917.                 printf("No field name provided -- separate with a ':'.\n");
  918.                 goto redo_other;
  919.              }
  920.              otherdata[j] = copystr(response);
  921.              break;
  922.            case MENU_EOF :
  923.              user_eof();
  924.              break;
  925.            case MENU_AMBIGUOUS :
  926.            case MENU_ERROR :
  927.            default :
  928.              fprintf(stderr,"Impossible rval from add_other menu_match\n");
  929.              save_and_exit(-1);
  930.          }
  931.      }
  932.   }
  933.  
  934.   add_entry :   
  935.  
  936.   basicdata[N_BASIC_FIELDS - 1] = timestring();
  937.   
  938.   rlink = create_entry(basicdata,otherdata);
  939.   clear_the_screen();
  940.   display_entry(get_entry(rlink));
  941.   if (add_the_entry()) {
  942.      printf (
  943.          "Adding entry for %s to rolodex\n",
  944.          get_basic_rolo_field((int) R_NAME,get_entry(rlink))
  945.       );
  946.      rolo_insert(rlink,compare_links);
  947.      changed = 1;
  948.      sleep(2);
  949.   }
  950.   else {
  951.      return;
  952.   }
  953.  
  954. }
  955.  
  956.  
  957. entry_action (rlink) Ptr_Rolo_List rlink;
  958.  
  959. {
  960.   static entry_menu_displayed = 0;
  961.   int rval,menuval;
  962.   char *response;
  963.   
  964.   if (!entry_menu_displayed) cathelpfile(libdir("entrymenu"),0,0);
  965.   entry_menu_displayed = 1;
  966.   
  967.   redo :
  968.   
  969.   rval = menu_match (
  970.        &menuval, &response,
  971.        "Action (? for help) : ",
  972.        0,1,1,1,7,
  973.        "\\",E_ABORT,
  974.        "?",E_HELP,
  975.        "",E_CONTINUE,
  976.        "-",E_DELETE,
  977.        "+",E_UPDATE,
  978.        "<",E_PREV,
  979.        "%",E_SCAN
  980.     );
  981.     
  982.   if (rval != MENU_MATCH) {
  983.      if (rval == MENU_EOF) user_eof();
  984.      fprintf(stderr,"Impossible return from entry_action menu_match\n");
  985.      save_and_exit(-1);
  986.   }
  987.  
  988.   switch (menuval) {
  989.     case E_ABORT :
  990.     case E_CONTINUE :
  991.     case E_PREV :
  992.       break;
  993.     case E_SCAN :
  994.       rolo_peruse_mode(get_next_link(rlink));
  995.       break;
  996.     case E_UPDATE :
  997.       rolo_update_mode(rlink);
  998.       break;
  999.     case E_DELETE :
  1000.       rolo_delete(rlink);
  1001.       printf("Entry deleted\n");
  1002.       sleep(1);
  1003.       changed = 1;
  1004.       break;
  1005.     case E_HELP :
  1006.       cathelpfile (
  1007.           libdir(in_search_mode ? "esearchhelp" : "escanhelp"),
  1008.           "entry actions",
  1009.           1
  1010.        );
  1011.       any_char_to_continue();
  1012.       clear_the_screen();
  1013.       display_entry(get_entry(rlink));
  1014.       goto redo;
  1015.       break;
  1016.     default :
  1017.       fprintf(stderr,"Impossible menuval in entry_action\n");
  1018.       save_and_exit(-1);
  1019.   }
  1020.  
  1021.   return(menuval);
  1022.   
  1023. }
  1024.  
  1025.  
  1026. display_list_of_entries (rlist) Ptr_Rolo_List rlist;
  1027.  
  1028. {
  1029.   Ptr_Rolo_List old;
  1030.         
  1031.   while (rlist != 0) {        
  1032.     
  1033.     if (!get_matched(rlist)) goto next;
  1034.         
  1035.     loop :    
  1036.     
  1037.     display_entry(get_entry(rlist));
  1038.     
  1039.     switch (entry_action(rlist)) {
  1040.       case E_CONTINUE :
  1041.         break;
  1042.       case E_ABORT :
  1043.         return;
  1044.         break;
  1045.       case E_PREV :
  1046.         old = rlist;
  1047.         find_prev_match :
  1048.         if (get_prev_link(rlist) == 0) {
  1049.            rlist = old;
  1050.            printf("No previous entry in scan list\n");
  1051.            sleep(2);
  1052.         }
  1053.         else {
  1054.            rlist = get_prev_link(rlist);
  1055.            if (!get_matched(rlist)) goto find_prev_match;
  1056.         }
  1057.         goto loop;
  1058.         break;
  1059.       default :
  1060.         printf("Displaying next entry in scan list...\n");
  1061.         sleep(1);
  1062.         break;
  1063.     }
  1064.     
  1065.     next :
  1066.     
  1067.     rlist = get_next_link(rlist);
  1068.     
  1069.   }
  1070.   
  1071.   printf("No further entries to scan...\n");
  1072.   sleep(2);     
  1073.   
  1074. }
  1075.   
  1076.  
  1077. rolo_peruse_mode (first_rlink) Ptr_Rolo_List first_rlink;
  1078.  
  1079. {
  1080.   int rval;
  1081.   Ptr_Rolo_List rlist = first_rlink;
  1082.   if (0 == Begin_Rlist) {
  1083.      fprintf(stderr,"No further entries in rolodex...\n");
  1084.      sleep(2);
  1085.      return;
  1086.   }
  1087.   while (rlist != 0) {  
  1088.     set_matched(rlist);
  1089.     rlist = get_next_link(rlist);
  1090.   }    
  1091.   display_list_of_entries(first_rlink);
  1092.   rlist = first_rlink;
  1093.   while (rlist != 0) {  
  1094.     unset_matched(rlist);
  1095.     rlist = get_next_link(rlist);
  1096.   }    
  1097. }
  1098. SHAR_EOF
  1099. if test 8950 -ne "`wc -c < 'operations.c'`"
  1100. then
  1101.     echo shar: error transmitting "'operations.c'" '(should have been 8950 characters)'
  1102. fi
  1103. fi
  1104. echo shar: extracting "'options.c'" '(6785 characters)'
  1105. if test -f 'options.c'
  1106. then
  1107.     echo shar: will not over-write existing file "'options.c'"
  1108. else
  1109. cat << \SHAR_EOF > 'options.c'
  1110. #include <sys/file.h>
  1111. #include <stdio.h>
  1112. #include <ctype.h>
  1113. #include <sgtty.h>
  1114. #include <sys/time.h>
  1115. #include <signal.h>
  1116.  
  1117. #include "sys5.h"
  1118.  
  1119. #ifdef TMC
  1120. #include <ctools.h>
  1121. #else
  1122. #include "ctools.h"
  1123. #endif
  1124. #include "args.h"
  1125. #include "menu.h"
  1126. #include "mem.h"
  1127.  
  1128. #include "rolofiles.h"
  1129. #include "rolodefs.h"
  1130. #include "datadef.h"
  1131. #include "choices.h"
  1132.  
  1133.  
  1134. print_short ()
  1135.  
  1136. /* print the names and phone numbers of everyone in the rolodex. */
  1137.  
  1138. { 
  1139.  
  1140.   Ptr_Rolo_List rptr;
  1141.   Ptr_Rolo_Entry entry;
  1142.         
  1143.   rptr = Begin_Rlist;
  1144.   if (rptr == 0) {
  1145.      fprintf(stderr,"No entries to print out...\n");
  1146.      return;
  1147.   }
  1148.    
  1149.   fprintf (
  1150.      stdout,
  1151.      "\nNAME                      WORK PHONE                HOME PHONE"
  1152.    );
  1153.   fprintf (
  1154.      stdout,
  1155.      "\n----                      ----------                ----------\n\n\n"
  1156.    );
  1157.  
  1158.    while (rptr != 0) {
  1159.         entry = get_entry(rptr);
  1160.         fprintf (
  1161.             stdout,
  1162.             "%-25s %-25s %-25s\n",
  1163.             get_basic_rolo_field((int) R_NAME,entry),
  1164.             get_basic_rolo_field((int) R_WORK_PHONE,entry),
  1165.             get_basic_rolo_field((int) R_HOME_PHONE,entry)
  1166.          );   
  1167.          rptr = get_next_link(rptr);
  1168.    }       
  1169.    
  1170.  }  
  1171.    
  1172.  
  1173. person_match (person,entry) char *person; Ptr_Rolo_Entry entry; 
  1174.  
  1175. /* Match against a rolodex entry's Name and Company fields. */
  1176. /* Thus if I say 'rolo CCA' I will find people who work at CCA. */
  1177. /* This is good because sometimes you will forget a name but remember */
  1178. /* the company the person works for. */
  1179.  
  1180. { 
  1181.   char *name, *company;        
  1182.   int len;
  1183.   len = strlen(person);
  1184.   name = get_basic_rolo_field((int) R_NAME,entry);
  1185.   company = get_basic_rolo_field((int) R_COMPANY,entry);
  1186.   if (strncsearch(name,strlen(name),person,len)) return(1);
  1187.   if (strncsearch(company,strlen(company),person,len)) return(1);
  1188.   return(0);
  1189. }
  1190.  
  1191.  
  1192. int find_all_person_matches (person) char *person;
  1193.  
  1194. {
  1195.   Ptr_Rolo_List rptr = Begin_Rlist;        
  1196.   int count = 0;
  1197.   while (rptr != 0) {
  1198.     unset_matched(rptr);
  1199.     if (person_match(person,get_entry(rptr))) {
  1200.        set_matched(rptr);
  1201.        count++;
  1202.     }
  1203.     rptr = get_next_link(rptr);
  1204.   }
  1205.   return(count);
  1206. }
  1207.  
  1208.  
  1209. look_for_person (person) char *person; 
  1210.  
  1211. /* search against Name and Company over the rolodex.  If a match is found */
  1212. /* display the entry and give the user a choice of what to do next. */
  1213.  
  1214. {
  1215.   Ptr_Rolo_List rptr;        
  1216.   int found = 0,result,nmatches;
  1217.   static displayed_menu = 0;
  1218.   char *response;
  1219.   
  1220.   rptr = Begin_Rlist;        
  1221.   while (rptr != 0) {        
  1222.     if (person_match(person,get_entry(rptr))) {
  1223.        clear_the_screen();
  1224.        display_entry(get_entry(rptr));
  1225.        if (!found) {
  1226.           nmatches = find_all_person_matches(person);
  1227.           if (nmatches > 1) {
  1228.              printf (
  1229.                 "There are %d other entries which match '%s'\n\n",
  1230.                 nmatches - 1, person
  1231.               );
  1232.           }
  1233.        }
  1234.        found = 1;
  1235.        try_again :
  1236.        if (!displayed_menu) cathelpfile(libdir("poptionmenu"),0,0);
  1237.        displayed_menu = 1;
  1238.        menu_match (
  1239.             &result,
  1240.             &response,
  1241.             "Select option (? for help): ",
  1242.             0,1,1,1,6,
  1243.             "Continue",P_CONTINUE,
  1244.             "",P_CONTINUE,
  1245.             "Next",P_NEXT_PERSON,
  1246.             "\\",P_ABORT,
  1247.             "Help",P_HELP,
  1248.             "?",P_HELP
  1249.          );
  1250.        switch (result) {
  1251.          case P_CONTINUE :
  1252.            break;
  1253.          case P_NEXT_PERSON :
  1254.            return;
  1255.            break;
  1256.          case P_ABORT :
  1257.            roloexit(0);
  1258.            break;
  1259.          case P_HELP :
  1260.            cathelpfile(libdir("poptionshelp"),"person search options",1);
  1261.            goto try_again;
  1262.          default :
  1263.            fprintf(stderr,"Impossible return from menu_match\n");
  1264.            exit(-1);
  1265.        }
  1266.     }
  1267.     rptr = get_next_link(rptr);
  1268.   }
  1269.   if (!found) {
  1270.      fprintf(stderr,"\nNo entry found for '%s'\n\n",person);
  1271.      sleep(2);
  1272.   }
  1273.   else {
  1274.      printf("No further matches for '%s'\n",person);
  1275.      sleep(2);
  1276.   }   
  1277. }
  1278.  
  1279.  
  1280. print_people ()
  1281.  
  1282. {
  1283.   int index;
  1284.   char *person;
  1285.   index = 1;
  1286.   while (T) {
  1287.      if (0 == (person = non_option_arg(index++))) break;
  1288.      look_for_person(person);
  1289.   }
  1290. }
  1291.  
  1292.  
  1293. interactive_rolo ()
  1294.  
  1295. /* Top level of the iteractive rolodex.  This code is just a big switch */
  1296. /* which passes responsibility off to various routines in 'operations.c' */
  1297. /* and 'update.c' */
  1298.  
  1299. {
  1300.  
  1301.   int result,rval,field_index;
  1302.   char *response,*field_name,*search_string;
  1303.  
  1304.   fprintf(stdout,"\n\nTMC ROLODEX, Version %s\n\n\n",VERSION);        
  1305.   
  1306.   while (1) {        
  1307.         
  1308.     cathelpfile(libdir("mainmenu"),0,0);
  1309.     rval = menu_match (
  1310.          &result,
  1311.          &response,
  1312.          "Select option (? for help): ",
  1313.          0,1,0,1,7,
  1314.          "+",M_ADD,
  1315.          "%",M_PERUSE,
  1316.          "\\",M_EXIT,
  1317.          "?",M_HELP,
  1318.          "*",M_SAVE,
  1319.          "$",M_SEARCH_BY_OTHER,
  1320.          "!",M_PRINT_TO_LASER_PRINTER
  1321.       );
  1322.       
  1323.     switch (rval) {
  1324.         
  1325.       case MENU_AMBIGUOUS :
  1326.       case MENU_ERROR :
  1327.         fprintf(stderr,"Impossible return 1 from main menu_match\n");
  1328.         exit(-1);
  1329.         break;
  1330.         
  1331.       case MENU_NO_MATCH :
  1332.         response = copystr(response);
  1333.         rolo_search_mode((int) R_NAME,Field_Names[(int) R_NAME],response);
  1334.         break;
  1335.         
  1336.       case MENU_MATCH :
  1337.         
  1338.         switch (result) {
  1339.           case M_ADD :
  1340.             rolo_add();
  1341.             break;
  1342.           case M_SEARCH_BY_OTHER :
  1343.             if ((-1 == select_field_to_search_by(&field_index,&field_name)) ||
  1344.                 (0 == (search_string = select_search_string()))) {
  1345.                break;
  1346.             }
  1347.             rolo_search_mode(field_index,field_name,search_string);
  1348.             break;
  1349.           case M_PRINT_TO_LASER_PRINTER :
  1350.             fprintf(stderr,"Not implemented\n");
  1351.             sleep(1);
  1352.             break;
  1353.           case M_PERUSE :
  1354.             rolo_peruse_mode(Begin_Rlist);
  1355.             break;
  1356.           case M_EXIT :
  1357.             save_and_exit(0);
  1358.             break;
  1359.           case M_SAVE :
  1360.             if (changed) {
  1361.                save_to_disk();
  1362.                sleep(1);
  1363.             }
  1364.             else {
  1365.                printf("No changes to be saved...\n");
  1366.                sleep(2);
  1367.             }
  1368.             break;
  1369.           case M_HELP :
  1370.             cathelpfile(libdir("moptionhelp"),"top level menu",1);
  1371.             any_char_to_continue();
  1372.             break;
  1373.           default :
  1374.             fprintf(stderr,"Impossible result from menu_match...\n");
  1375.             save_and_exit(-1);
  1376.         }
  1377.         break;
  1378.             
  1379.       case MENU_EOF :
  1380.         user_eof();
  1381.         break;
  1382.         
  1383.       default :
  1384.         fprintf(stderr,"Impossible return 2 from menu_match\n");
  1385.         save_and_exit(-1);
  1386.         
  1387.     }
  1388.     
  1389.     clear_the_screen();
  1390.     
  1391.   }
  1392.  
  1393. }
  1394. SHAR_EOF
  1395. if test 6785 -ne "`wc -c < 'options.c'`"
  1396. then
  1397.     echo shar: error transmitting "'options.c'" '(should have been 6785 characters)'
  1398. fi
  1399. fi
  1400. echo shar: extracting "'rlist.c'" '(2445 characters)'
  1401. if test -f 'rlist.c'
  1402. then
  1403.     echo shar: will not over-write existing file "'rlist.c'"
  1404. else
  1405. cat << \SHAR_EOF > 'rlist.c'
  1406. #include "datadef.h"
  1407.  
  1408.  
  1409. int rlength (rlist) Ptr_Rolo_List rlist;
  1410. {
  1411.   return((rlist == 0) ? 0 : 1 + rlength(get_next_link(rlist)));
  1412. }  
  1413.   
  1414.  
  1415. Ptr_Rolo_List new_link_with_entry ()
  1416. {
  1417.   Ptr_Rolo_List newlink;        
  1418.   Ptr_Rolo_Entry newentry;
  1419.   newlink = (Ptr_Rolo_List) rolo_emalloc(sizeof(Rolo_List));
  1420.   unset_matched(newlink);
  1421.   newentry = (Ptr_Rolo_Entry) rolo_emalloc(sizeof(Rolo_Entry));
  1422.   set_n_others(newentry,0);        
  1423.   newentry -> other_fields = 0;
  1424.   set_entry(newlink,newentry);
  1425.   return(newlink);
  1426. }
  1427.  
  1428.  
  1429. rolo_insert (link,compare) Ptr_Rolo_List link; int (*compare)();
  1430.  
  1431. {
  1432.   Ptr_Rolo_List rptr;        
  1433.         
  1434.   if (Begin_Rlist == 0) {
  1435.      Begin_Rlist = link;
  1436.      End_Rlist = link;
  1437.      set_prev_link(link,0);
  1438.      set_next_link(link,0);
  1439.      return;
  1440.   }
  1441.   
  1442.   /* find the element it goes before, alphabetically, and insert it */
  1443.  
  1444.   rptr = Begin_Rlist;
  1445.   while (rptr != 0) {
  1446.     if (1 == (*compare)(rptr,link)) {
  1447.        set_prev_link(link,get_prev_link(rptr));
  1448.        set_next_link(link,rptr);
  1449.        if (get_prev_link(rptr) != 0) 
  1450.           set_next_link(get_prev_link(rptr),link);
  1451.        else
  1452.           Begin_Rlist = link;
  1453.        set_prev_link(rptr,link);
  1454.        return;
  1455.     }
  1456.     rptr = get_next_link(rptr);
  1457.   }
  1458.  
  1459.   /* it goes at the end */
  1460.   
  1461.   set_next_link(End_Rlist,link);
  1462.   set_prev_link(link,End_Rlist);
  1463.   set_next_link(link,0);
  1464.   End_Rlist = link;
  1465.   return;
  1466.  
  1467. }
  1468.  
  1469.  
  1470. rolo_delete (link) Ptr_Rolo_List link;
  1471.  
  1472. {
  1473.   if (get_next_link(link) == 0 && get_prev_link(link) == 0) {
  1474.      Begin_Rlist = 0;
  1475.      End_Rlist = 0;
  1476.      return;
  1477.   }
  1478.  
  1479.   if (get_prev_link(link) == 0) {
  1480.      Begin_Rlist = get_next_link(link);
  1481.      set_prev_link(Begin_Rlist,0);
  1482.      return;
  1483.   }
  1484.  
  1485.   if (get_next_link(link) == 0) {
  1486.      End_Rlist = get_prev_link(link);
  1487.      set_next_link(End_Rlist,0);
  1488.      return;
  1489.   }
  1490.  
  1491.   set_next_link(get_prev_link(link),get_next_link(link));
  1492.   set_prev_link(get_next_link(link),get_prev_link(link));
  1493.   return;
  1494.  
  1495. }
  1496.  
  1497.  
  1498. compare_links (l1,l2) Ptr_Rolo_List l1,l2;
  1499.  
  1500. {
  1501.   Ptr_Rolo_Entry e1,e2;        
  1502.   char *n1,*n2;
  1503.   e1 = get_entry(l1);        
  1504.   e2 = get_entry(l2);        
  1505.   n1 = get_basic_rolo_field((int) R_NAME,e1);
  1506.   n2 = get_basic_rolo_field((int) R_NAME,e2);
  1507.   return(nocase_compare(n1,strlen(n1),n2,strlen(n2)));
  1508. }  
  1509.   
  1510.  
  1511. rolo_reorder ()
  1512. {
  1513.   Ptr_Rolo_List rptr,oldlink;
  1514.   rptr = Begin_Rlist;
  1515.   Begin_Rlist = 0;
  1516.   while (rptr != 0) {
  1517.     oldlink = get_next_link(rptr);
  1518.     rolo_insert(rptr,compare_links);
  1519.     rptr = oldlink;
  1520.   }
  1521. }
  1522.  
  1523.  
  1524. SHAR_EOF
  1525. if test 2445 -ne "`wc -c < 'rlist.c'`"
  1526. then
  1527.     echo shar: error transmitting "'rlist.c'" '(should have been 2445 characters)'
  1528. fi
  1529. fi
  1530. echo shar: extracting "'rolo.c'" '(8738 characters)'
  1531. if test -f 'rolo.c'
  1532. then
  1533.     echo shar: will not over-write existing file "'rolo.c'"
  1534. else
  1535. cat << \SHAR_EOF > 'rolo.c'
  1536. #include <sys/file.h>
  1537. #include <stdio.h>
  1538. #include <ctype.h>
  1539. #include <sgtty.h>
  1540. #include <signal.h>
  1541. #include <curses.h>
  1542. #include <pwd.h>
  1543.  
  1544. #include "sys5.h"
  1545.  
  1546. #ifdef TMC
  1547. #include <ctools.h>
  1548. #else
  1549. #include "ctools.h"
  1550. #endif
  1551. #include "args.h"
  1552. #include "menu.h"
  1553. #include "mem.h"
  1554.  
  1555. #include "rolofiles.h"
  1556. #include "rolodefs.h"
  1557. #include "datadef.h"
  1558.  
  1559.  
  1560. static char rolodir[DIRPATHLEN];        /* directory where rolo data is */
  1561. static char filebuf[DIRPATHLEN];        /* stores result of homedir() */
  1562.  
  1563. int changed = 0;
  1564. int reorder_file = 0;
  1565. int rololocked = 0;
  1566. int in_search_mode = 0;
  1567.  
  1568.  
  1569. char *rolo_emalloc (size) int size;
  1570.  
  1571. /* error handling memory allocator */
  1572.  
  1573. {
  1574.   char *rval;        
  1575.   if (0 == (rval = malloc(size))) {        
  1576.      fprintf(stderr,"Fatal error:  out of memory\n");
  1577.      save_and_exit(-1);
  1578.   }
  1579.   return(rval);
  1580. }  
  1581.  
  1582.         
  1583. char *copystr (s) char *s;
  1584.  
  1585. /* memory allocating string copy routine */
  1586.  
  1587.  
  1588. {
  1589.  char *copy;        
  1590.  if (s == 0) return(0);
  1591.  copy = rolo_emalloc(strlen(s) + 1);
  1592.  strcpy(copy,s);
  1593.  return(copy);
  1594. }
  1595.  
  1596.  
  1597. char *timestring ()
  1598.  
  1599. /* returns a string timestamp */
  1600.  
  1601. {
  1602.   char *s;        
  1603.   long timeval;
  1604.   time(&timeval);
  1605.   s = ctime(&timeval);  
  1606.   s[strlen(s) - 1] = '\0';
  1607.   return(copystr(s));
  1608. }  
  1609.   
  1610.  
  1611. user_interrupt ()
  1612.  
  1613. /* if the user hits C-C (we assume he does it deliberately) */
  1614.  
  1615. {
  1616.   unlink(homedir(ROLOLOCK));
  1617.   fprintf(stderr,"\nAborting rolodex, no changes since last save recorded\n");
  1618.   exit(-1);  
  1619. }  
  1620.  
  1621.  
  1622. user_eof ()
  1623.  
  1624. /* if the user hits C-D */
  1625.  
  1626. {
  1627.   unlink(homedir(ROLOLOCK));        
  1628.   fprintf(stderr,"\nUnexpected EOF on terminal. Saving rolodex and exiting\n");
  1629.   save_and_exit(-1);        
  1630. }
  1631.  
  1632.  
  1633. roloexit (rval) int rval;
  1634. {
  1635.   if (rololocked) unlink(homedir(ROLOLOCK));        
  1636.   exit(rval);
  1637. }  
  1638.  
  1639.  
  1640. save_to_disk ()
  1641.  
  1642. /* move the old rolodex to a backup, and write out the new rolodex and */
  1643. /* a copy of the new rolodex (just for safety) */
  1644.  
  1645. {
  1646.   FILE *tempfp,*copyfp;        
  1647.   char d1[DIRPATHLEN], d2[DIRPATHLEN];
  1648.   int r;
  1649.         
  1650.   tempfp = fopen(homedir(ROLOTEMP),"w");
  1651.   copyfp = fopen(homedir(ROLOCOPY),"w");
  1652.   if (tempfp == NULL || copyfp == NULL) {
  1653.      fprintf(stderr,"Unable to write rolodex...\n");
  1654.      fprintf(stderr,"Any changes made have not been recorded\n");
  1655.      roloexit(-1);
  1656.   }
  1657.   write_rolo(tempfp,copyfp);
  1658.   fclose(tempfp);
  1659.   fclose(copyfp);
  1660.   if (rename(strcpy(d1,homedir(ROLODATA)),strcpy(d2,homedir(ROLOBAK))) ||
  1661.       rename(strcpy(d1,homedir(ROLOTEMP)),strcpy(d2,homedir(ROLODATA)))) {
  1662.      fprintf(stderr,"Rename failed.  Revised rolodex is in %s\n",ROLOCOPY);
  1663.      roloexit(-1);
  1664.   }
  1665.   printf("Rolodex saved\n");
  1666.   sleep(1);
  1667.   changed = 0;
  1668. }
  1669.   
  1670.  
  1671. save_and_exit (rval) int rval;
  1672. {
  1673.   if (changed) save_to_disk();        
  1674.   roloexit(rval);        
  1675. }
  1676.  
  1677.  
  1678. extern struct passwd *getpwnam();
  1679.  
  1680. char *home_directory (name) char *name;
  1681. {
  1682.   struct passwd *pwentry;
  1683.   if (0 == (pwentry = getpwnam(name))) return("");
  1684.   return(pwentry -> pw_dir);
  1685. }        
  1686.  
  1687.  
  1688. char *homedir (filename) char *filename;
  1689.  
  1690. /* e.g., given "rolodex.dat", create "/u/massar/rolodex.dat" */
  1691. /* rolodir generally the user's home directory but could be someone else's */
  1692. /* home directory if the -u option is used. */
  1693.  
  1694. {
  1695.   nbuffconcat(filebuf,3,rolodir,"/",filename);
  1696.   return(filebuf);
  1697. }
  1698.  
  1699.  
  1700. char *libdir (filename) char *filename;
  1701.  
  1702. /* return a full pathname into the rolodex library directory */
  1703. /* the string must be copied if it is to be saved! */
  1704.  
  1705. {
  1706.   nbuffconcat(filebuf,3,ROLOLIB,"/",filename);        
  1707.   return(filebuf);        
  1708. }
  1709.  
  1710.  
  1711. rolo_only_to_read () 
  1712. {
  1713.   return(option_present(SUMMARYFLAG) || n_non_option_args() > 0);
  1714. }
  1715.  
  1716.  
  1717. locked_action () 
  1718. {
  1719.   if (option_present(OTHERUSERFLAG)) {        
  1720.      fprintf(stderr,"Someone else is modifying that rolodex, sorry\n");
  1721.      exit(-1);
  1722.   }
  1723.   else {
  1724.      cathelpfile(libdir("lockinfo"),"locked rolodex",0);
  1725.      exit(-1);
  1726.   }
  1727. }  
  1728.   
  1729.  
  1730. main (argc,argv) int argc; char *argv[];
  1731.  
  1732. {
  1733.     int fd,in_use,read_only,rolofd;
  1734.     Bool not_own_rolodex;        
  1735.     char *user;
  1736.     FILE *tempfp;
  1737.     
  1738.     clearinit();
  1739.     clear_the_screen();
  1740.     
  1741.     /* parse the options and arguments, if any */
  1742.     
  1743.     switch (get_args(argc,argv,T,T)) {
  1744.         case ARG_ERROR : 
  1745.           roloexit(-1);
  1746.         case NO_ARGS :
  1747.           break;
  1748.         case ARGS_PRESENT :
  1749.           if (ALL_LEGAL != legal_options(LEGAL_OPTIONS)) {
  1750.                 fprintf(stderr,"illegal option\nusage: %s\n",USAGE);
  1751.                 roloexit(-1);
  1752.           }
  1753.     }
  1754.     
  1755.     /* find the directory in which the rolodex file we want to use is */
  1756.     
  1757.     not_own_rolodex = option_present(OTHERUSERFLAG);        
  1758.     if (not_own_rolodex) {
  1759.        if (NIL == (user = option_arg(OTHERUSERFLAG,1)) || 
  1760.            n_option_args(OTHERUSERFLAG) != 1) {
  1761.           fprintf(stderr,"Illegal syntax using -u option\nusage: %s\n",USAGE);
  1762.           roloexit(-1);
  1763.        }
  1764.     }        
  1765.     else {
  1766.        if (0 == (user = getenv("HOME"))) {
  1767.           fprintf(stderr,"Cant find your home directory, no HOME\n");
  1768.           roloexit(-1);
  1769.        }
  1770.     }
  1771.     
  1772.     if (not_own_rolodex) {
  1773.        strcpy(rolodir,home_directory(user));
  1774.        if (*rolodir == '\0') {
  1775.           fprintf(stderr,"No user %s is known to the system\n",user);
  1776.           roloexit(-1);
  1777.        }
  1778.     }
  1779.     else strcpy(rolodir,user);
  1780.     
  1781.     /* is the rolodex readable? */
  1782.     
  1783.     if (0 != access(homedir(ROLODATA),R_OK)) {
  1784.         
  1785.        /* No.  if it exists and we cant read it, that's an error */
  1786.         
  1787.        if (0 == access(homedir(ROLODATA),F_OK)) { 
  1788.           fprintf(stderr,"Cant access rolodex data file to read\n");
  1789.           roloexit(-1);
  1790.        }
  1791.        
  1792.        /* if it doesn't exist, should we create one? */
  1793.        
  1794.        if (option_present(OTHERUSERFLAG)) {
  1795.           fprintf(stderr,"No rolodex file belonging to %s found\n",user);
  1796.           roloexit(-1);
  1797.        }
  1798.        
  1799.        /* try to create it */
  1800.        
  1801.        if (-1 == (fd = creat(homedir(ROLODATA),0644))) {
  1802.           fprintf(stderr,"couldnt create rolodex in your home directory\n");
  1803.           roloexit(-1);
  1804.        }
  1805.        
  1806.        else {
  1807.           close(fd);
  1808.           fprintf(stderr,"Creating empty rolodex...\n");
  1809.        }
  1810.  
  1811.     }
  1812.     
  1813.     /* see if someone else is using it */
  1814.     
  1815.     in_use = (0 == access(homedir(ROLOLOCK),F_OK));
  1816.     
  1817.     /* are we going to access the rolodex only for reading? */
  1818.     
  1819.     if (!(read_only = rolo_only_to_read())) {
  1820.     
  1821.        /* No.  Make sure no one else has it locked. */
  1822.         
  1823.        if (in_use) {
  1824.           locked_action();
  1825.        }
  1826.         
  1827.        /* create a lock file.  Catch interrupts so that we can remove */
  1828.        /* the lock file if the user decides to abort */
  1829.        
  1830.        if (!option_present(NOLOCKFLAG)) {
  1831.           if ((fd = open(homedir(ROLOLOCK),O_EXCL|O_CREAT,00200|00400)) < 0) {
  1832.              fprintf(stderr,"unable to create lock file...\n");
  1833.          exit(1);
  1834.       }
  1835.           rololocked = 1;
  1836.           close(fd);
  1837.           signal(SIGINT,user_interrupt);        
  1838.        }
  1839.         
  1840.        /* open a temporary file for writing changes to make sure we can */
  1841.        /* write into the directory */
  1842.        
  1843.        /* when the rolodex is saved, the old rolodex is moved to */
  1844.        /* a '~' file, the temporary is made to be the new rolodex, */
  1845.        /* and a copy of the new rolodex is made */
  1846.        
  1847.        if (NULL == (tempfp = fopen(homedir(ROLOTEMP),"w"))) {
  1848.            fprintf(stderr,"Can't open temporary file to write to\n");
  1849.            roloexit(-1);
  1850.        }        
  1851.        fclose(tempfp);
  1852.     
  1853.     }
  1854.        
  1855.     allocate_memory_chunk(CHUNKSIZE);
  1856.     
  1857.     if (NULL == (rolofd = open(homedir(ROLODATA),O_RDONLY))) {
  1858.         fprintf(stderr,"Can't open rolodex data file to read\n");
  1859.         roloexit(-1);
  1860.     }
  1861.     
  1862.     /* read in the rolodex from disk */
  1863.     /* It should never be out of order since it is written to disk ordered */
  1864.     /* but just in case... */
  1865.     
  1866.     if (!read_only) printf("Reading in rolodex from %s\n",homedir(ROLODATA));
  1867.     read_rolodex(rolofd);
  1868.     close(rolofd);
  1869.     if (!read_only) printf("%d entries listed\n",rlength(Begin_Rlist));
  1870.     if (reorder_file && !read_only) {
  1871.        fprintf(stderr,"Reordering rolodex...\n");
  1872.        rolo_reorder();
  1873.        fprintf(stderr,"Saving reordered rolodex to disk...\n");
  1874.        save_to_disk();
  1875.     }
  1876.        
  1877.     /* the following routines live in 'options.c' */
  1878.     
  1879.     /* -s option.  Prints a short listing of people and phone numbers to */
  1880.     /* standard output */
  1881.     
  1882.     if (option_present(SUMMARYFLAG)) {
  1883.         print_short();
  1884.         exit(0);
  1885.     }
  1886.     
  1887.     /* rolo <name1> <name2> ... */
  1888.     /* print out info about people whose names contain any of the arguments */
  1889.     
  1890.     if (n_non_option_args() > 0) {
  1891.        print_people();
  1892.        exit(0);
  1893.     }
  1894.     
  1895.     /* regular rolodex program */
  1896.     
  1897.     interactive_rolo();
  1898.     exit(0);
  1899.     
  1900. }    
  1901. SHAR_EOF
  1902. if test 8738 -ne "`wc -c < 'rolo.c'`"
  1903. then
  1904.     echo shar: error transmitting "'rolo.c'" '(should have been 8738 characters)'
  1905. fi
  1906. fi
  1907. echo shar: extracting "'rolodefs.h'" '(262 characters)'
  1908. if test -f 'rolodefs.h'
  1909. then
  1910.     echo shar: will not over-write existing file "'rolodefs.h'"
  1911. else
  1912. cat << \SHAR_EOF > 'rolodefs.h'
  1913. #define VERSION "2.0"
  1914.  
  1915. #define CHUNKSIZE 100000        /* storage size for holding data file */
  1916.  
  1917. #define NOLOCKFLAG 'l'
  1918. #define SUMMARYFLAG 's'
  1919. #define OTHERUSERFLAG 'u'
  1920.  
  1921. #define LEGAL_OPTIONS "lsu"
  1922. #define USAGE "rolo [ person1 person2 ...] [ -l -s -u user ] "
  1923. SHAR_EOF
  1924. if test 262 -ne "`wc -c < 'rolodefs.h'`"
  1925. then
  1926.     echo shar: error transmitting "'rolodefs.h'" '(should have been 262 characters)'
  1927. fi
  1928. fi
  1929. echo shar: extracting "'rolofiles.h'" '(280 characters)'
  1930. if test -f 'rolofiles.h'
  1931. then
  1932.     echo shar: will not over-write existing file "'rolofiles.h'"
  1933. else
  1934. cat << \SHAR_EOF > 'rolofiles.h'
  1935. #define ROLOBAK ".rolodex~"
  1936. #define ROLODATA ".rolodex.dat"
  1937. #define ROLOPRINT "roloprint.text"
  1938. #define ROLOLOCK ".rolodexdata.lock"
  1939. #define ROLOTEMP ".rolotemp"
  1940. #define ROLOCOPY ".rolocopy"
  1941.  
  1942. /* This is now defined in the Makefile */
  1943.  
  1944. /*  #define ROLOLIB "/usr/local/lib/rolo"  */
  1945. SHAR_EOF
  1946. if test 280 -ne "`wc -c < 'rolofiles.h'`"
  1947. then
  1948.     echo shar: error transmitting "'rolofiles.h'" '(should have been 280 characters)'
  1949. fi
  1950. fi
  1951. echo shar: extracting "'search.c'" '(9108 characters)'
  1952. if test -f 'search.c'
  1953. then
  1954.     echo shar: will not over-write existing file "'search.c'"
  1955. else
  1956. cat << \SHAR_EOF > 'search.c'
  1957. #include <stdio.h>
  1958. #include <ctype.h>
  1959.  
  1960. #include "sys5.h"
  1961.  
  1962. #ifdef TMC
  1963. #include <ctools.h>
  1964. #else
  1965. #include "ctools.h"
  1966. #endif
  1967. #include "args.h"
  1968. #include "menu.h"
  1969. #include "mem.h"
  1970.  
  1971. #include "rolofiles.h"
  1972. #include "rolodefs.h"
  1973. #include "datadef.h"
  1974. #include "choices.h"
  1975.  
  1976.  
  1977. char *select_search_string ()
  1978.  
  1979. /* returns 0 if user wants to quit, otherwise returns a user-provided string */
  1980.  
  1981. {
  1982.   int rval;        
  1983.   char *response;
  1984.   rval = rolo_menu_data_help_or_abort (        
  1985.               "Enter string to search for: ",
  1986.               "searchstringhelp",
  1987.               "string to search for",
  1988.               &response
  1989.           );
  1990.   switch (rval) {          
  1991.     case MENU_ABORT :
  1992.       return(0);
  1993.       break;
  1994.     case MENU_DATA :
  1995.       return(copystr(response));
  1996.       break;
  1997.   }
  1998. }  
  1999.   
  2000.  
  2001. select_field_to_search_by (ptr_index,ptr_name) int *ptr_index; char **ptr_name;
  2002.  
  2003. /* returns -1 if the user wishes to abort, otherwise returns 0. */
  2004. /* if the user wishes to search by a user-defined field, *ptr_index is OTHER */
  2005. /* and *ptr_name is the user-provided name of the field. */
  2006.  
  2007. {
  2008.   char *response;
  2009.   int nchoices = N_BASIC_FIELDS;
  2010.   int field_index,rval;
  2011.   
  2012.   redo :
  2013.   
  2014.   /* list out each basic field that the user can search by.   The user is */
  2015.   /* also given an option to search by a user-provided field.   At the */
  2016.   /* moment you cannot search by 'Date Updated' */
  2017.   
  2018.   display_field_names();  
  2019.   
  2020.   reask :
  2021.   
  2022.   rval = rolo_menu_number_help_or_abort (
  2023.        "Number of item to search by? ",
  2024.        1,nchoices,&field_index
  2025.     );
  2026.     
  2027.   switch (rval) {
  2028.         
  2029.     case MENU_ABORT :
  2030.       return(-1);
  2031.       break;
  2032.       
  2033.     case MENU_HELP :
  2034.       cathelpfile(libdir("fieldsearchhelp"),"entering search field",1);
  2035.       any_char_to_continue();
  2036.       goto redo;
  2037.       break;
  2038.       
  2039.     case MENU_DATA :
  2040.     
  2041.       if (field_index != nchoices) {
  2042.          *ptr_index = field_index - 1;
  2043.          *ptr_name = copystr(Field_Names[*ptr_index]);
  2044.          return(0);
  2045.       }
  2046.       
  2047.       /* the user wants to search by a user-specified field */
  2048.       
  2049.       else {
  2050.         
  2051.          reask2 :
  2052.         
  2053.          rval = rolo_menu_data_help_or_abort (
  2054.                     "Name of user-defined field? ",
  2055.                     "userfieldhelp",
  2056.                     "name of user field to search by",
  2057.                     &response
  2058.                  );
  2059.          switch (rval) {
  2060.            case MENU_ABORT :
  2061.              return(-1);
  2062.              break;
  2063.            case MENU_DATA :
  2064.              *ptr_index = OTHER;
  2065.              *ptr_name = copystr(response);           
  2066.              return(0);         
  2067.              break;
  2068.          }
  2069.       }
  2070.       break;
  2071.   }
  2072.   
  2073. }  
  2074.       
  2075.  
  2076. match_by_name_or_company (search_string,sslen) char *search_string; int sslen;
  2077.  
  2078. {
  2079.   char *name,*company;
  2080.   Ptr_Rolo_Entry entry;        
  2081.   Ptr_Rolo_List rlist;
  2082.   int count = 0;
  2083.   
  2084.   rlist = Begin_Rlist;
  2085.   while (rlist != 0) {  
  2086.     entry = get_entry(rlist);
  2087.     name = get_basic_rolo_field((int) R_NAME,entry);
  2088.     company = get_basic_rolo_field((int) R_COMPANY,entry);
  2089.     if (strncsearch(name,strlen(name),search_string,sslen) ||
  2090.         strncsearch(company,strlen(company),search_string,sslen)) {
  2091.        set_matched(rlist);
  2092.        count++;
  2093.     }
  2094.   }
  2095.   return(count);
  2096.   
  2097. }
  2098.  
  2099.  
  2100. match_link (rlink,field_index,field_name,fnlen,search_string,sslen)
  2101.  
  2102.   /* if a match is present, sets the 'matched' field in the link, and */
  2103.   /* returns 1, otherwise returns 0. */
  2104.  
  2105.   Ptr_Rolo_List rlink;
  2106.   int field_index;
  2107.   char *field_name;
  2108.   int fnlen;
  2109.   char *search_string;
  2110.   int sslen;
  2111.   
  2112. {
  2113.   Ptr_Rolo_Entry entry;        
  2114.   char *field;
  2115.   char name[100];
  2116.   int j;
  2117.         
  2118.   entry = get_entry(rlink);
  2119.   
  2120.   if (field_index == OTHER) {
  2121.      for (j = 0; j < get_n_others(entry); j++) {
  2122.          field = get_other_field(j,entry);
  2123.          while (*field != ':') *field++;
  2124.          *field = '\0';
  2125.          remove_excess_blanks(name,get_other_field(j,entry));
  2126.          *field++ = ':';
  2127.          if (0 != nocase_compare(name,strlen(name),field_name,fnlen)) {
  2128.             continue;
  2129.          }
  2130.          if (strncsearch(field,strlen(field),search_string,sslen)) {
  2131.             set_matched(rlink);
  2132.             return(1);
  2133.          }
  2134.      }
  2135.      return(0);
  2136.   }
  2137.   else {
  2138.      field = get_basic_rolo_field(field_index,entry);
  2139.      if (strncsearch(field,strlen(field),search_string,sslen)) {
  2140.         set_matched(rlink);
  2141.         return(1);
  2142.      }
  2143.      return(0);
  2144.   }
  2145.  
  2146. }
  2147.  
  2148.  
  2149. find_all_matches (field_index,field_name,search_string,ptr_first_match) 
  2150.  
  2151.   /* mark every entry in the rolodex which matches against the search_string */
  2152.   /* If the search_string is a substring of the data in the given field then */
  2153.   /* that is a match.  Return the number of matches.  If there are any */
  2154.   /* matches *ptr_first_match will contain the first matching link. */
  2155.  
  2156.   int field_index;
  2157.   char *field_name, *search_string;
  2158.   Ptr_Rolo_List *ptr_first_match;
  2159.  
  2160. {  
  2161.   char buffer[100];    
  2162.   int fnlen,sslen;
  2163.   int count = 0;
  2164.   Ptr_Rolo_List rlist = Begin_Rlist;
  2165.   
  2166.   remove_excess_blanks(buffer,field_name);
  2167.   fnlen = strlen(buffer);
  2168.   sslen = strlen(search_string);
  2169.   
  2170.   while (rlist != 0) {  
  2171.     unset_matched(rlist);
  2172.     if (match_link(rlist,field_index,buffer,fnlen,search_string,sslen)) {
  2173.        if (count++ == 0) *ptr_first_match = rlist;
  2174.     }
  2175.     rlist = get_next_link(rlist);
  2176.   }    
  2177.   
  2178.   return(count);
  2179.   
  2180. }
  2181.  
  2182.  
  2183. rolo_search_mode (field_index,field_name,search_string)
  2184.  
  2185.   int field_index;
  2186.   char *field_name;
  2187.   char *search_string;
  2188.  
  2189. {
  2190.   int rval,n,j,menuval,ival;
  2191.   char *response;
  2192.   Ptr_Rolo_List first_match,rmatch,rlist;
  2193.  
  2194.   /* mark every entry in the rolodex that satisfies the search criteria */
  2195.   /* and return the number of items so marked. */
  2196.   
  2197.   in_search_mode = 1;
  2198.   n = find_all_matches(field_index,field_name,search_string,&first_match);
  2199.  
  2200.   if (n == 0) {
  2201.      printf (
  2202.          "No match found for search string '%s' for field '%s'\n",
  2203.          search_string,
  2204.          field_name
  2205.       );
  2206.       sleep(2);
  2207.       goto rtn;
  2208.   }
  2209.  
  2210.   /* if the match is unique, just display the entry. */
  2211.   
  2212.   else if (n == 1) {
  2213.      display_entry(get_entry(first_match));
  2214.      switch (entry_action(first_match)) {
  2215.        case E_CONTINUE :
  2216.          printf("No further matches...\n");
  2217.          sleep(2);
  2218.          break;
  2219.        default :
  2220.          break;
  2221.      }
  2222.      goto rtn;
  2223.   }
  2224.  
  2225.   /* if there are too many matches to itemize them on a single small */
  2226.   /* screen, tell the user that there are lots of matches and suggest */
  2227.   /* he specify a better search string, but give him the option of */
  2228.   /* iterating through every match. */
  2229.   
  2230.   else if (n > MAXMATCHES) {
  2231.      clear_the_screen();
  2232.      printf("There are %d entries that match '%s' !\n",n,search_string);
  2233.      printf("Type 'v' to view them one by one,\n");
  2234.      printf("or '\\' to abort and enter a more specific search string: ");
  2235.      rval = rolo_menu_data_help_or_abort (
  2236.                  "","manymatchhelp","many matching entries",&response
  2237.               );
  2238.      if (rval == MENU_ABORT) goto rtn;              
  2239.      display_list_of_entries(Begin_Rlist);
  2240.      goto rtn;
  2241.   }
  2242.  
  2243.   /* there are a small number of matching entries.  List the name of each */
  2244.   /* matching entry and let the user select which one he wants to view, */
  2245.   /* or whether he wants to iterate through each matching entry. */
  2246.   
  2247.   else {
  2248.      relist :
  2249.      summarize_entry_list(Begin_Rlist,search_string);
  2250.      cathelpfile(libdir("pickentrymenu"),0,0);  
  2251.      rval = menu_match (
  2252.           &menuval,&response,
  2253.           ": ",
  2254.           0,1,0,1,4,
  2255.           "\\",S_ABORT,
  2256.           "?",S_HELP,
  2257.           "Help",S_HELP,
  2258.           "",S_SCAN_ONE_BY_ONE
  2259.        );
  2260.      switch (rval) {    
  2261.        case MENU_MATCH :
  2262.          switch (menuval) {
  2263.            case S_HELP :
  2264.              cathelpfile(libdir("pickentryhelp"),"selecting entry to view",1);
  2265.              any_char_to_continue();
  2266.              goto relist;
  2267.              break;
  2268.            case S_ABORT :
  2269.              goto rtn;
  2270.              break;
  2271.            case S_SCAN_ONE_BY_ONE :
  2272.              display_list_of_entries(Begin_Rlist);
  2273.              goto rtn;
  2274.              break;
  2275.          }
  2276.          break;
  2277.          
  2278.        /* make sure the user entered a valid integer, ival */
  2279.        /* if so, find the ivalth entry marked as matched in the rolodex */
  2280.        /* and display it. */
  2281.          
  2282.        case MENU_NO_MATCH : 
  2283.          ival = str_to_pos_int(response,1,n);
  2284.          if (ival < 0) {
  2285.             printf("Not a valid number... Please try again\n");
  2286.             sleep(2);
  2287.             goto relist;
  2288.          }
  2289.          rlist = Begin_Rlist;
  2290.          for (j = 0; j < ival; j++) {
  2291.              while (rlist != 0) {
  2292.                if (get_matched(rmatch = rlist)) break;
  2293.                rlist = get_next_link(rlist);
  2294.              }
  2295.              if (rlist != 0) rlist = get_next_link(rlist);                
  2296.          }
  2297.          display_entry(get_entry(rmatch));
  2298.          switch (entry_action(rmatch)) {
  2299.            case E_CONTINUE :
  2300.            case E_PREV :
  2301.              goto relist;
  2302.              break;
  2303.            default :
  2304.              goto rtn;
  2305.              break;
  2306.          }
  2307.          break;
  2308.      }
  2309.   }
  2310.  
  2311.   rtn :
  2312.   in_search_mode = 0;
  2313.   
  2314. }
  2315. SHAR_EOF
  2316. if test 9108 -ne "`wc -c < 'search.c'`"
  2317. then
  2318.     echo shar: error transmitting "'search.c'" '(should have been 9108 characters)'
  2319. fi
  2320. fi
  2321. echo shar: extracting "'update.c'" '(6022 characters)'
  2322. if test -f 'update.c'
  2323. then
  2324.     echo shar: will not over-write existing file "'update.c'"
  2325. else
  2326. cat << \SHAR_EOF > 'update.c'
  2327. #include <stdio.h>
  2328. #include <ctype.h>
  2329.  
  2330. #include "sys5.h"
  2331.  
  2332. #ifdef TMC
  2333. #include <ctools.h>
  2334. #else
  2335. #include "ctools.h"
  2336. #endif
  2337. #include "args.h"
  2338. #include "menu.h"
  2339. #include "mem.h"
  2340.  
  2341. #include "rolofiles.h"
  2342. #include "rolodefs.h"
  2343. #include "datadef.h"
  2344. #include "choices.h"
  2345.  
  2346.  
  2347. char *get_new_value () 
  2348. {
  2349.   char buffer[200];
  2350.   int rval;
  2351.   switch (rval = getline(stdin,buffer,199)) {
  2352.     case AT_EOF :
  2353.       user_eof();
  2354.       break;
  2355.     case TOO_MANY_CHARS :
  2356.       fprintf(stderr,"Line too long, truncated...\n");
  2357.       sleep(1);
  2358.       break;
  2359.     default :
  2360.       if ('\\' == *buffer && rval == 1) return(0);
  2361.       break;
  2362.   }
  2363.   return(copystr(buffer));
  2364. }  
  2365.   
  2366.  
  2367. Ptr_Rolo_Entry copy_entry (entry) Ptr_Rolo_Entry entry;
  2368. {
  2369.   Ptr_Rolo_Entry new_entry;        
  2370.   int j,n;        
  2371.   char **otherfields;
  2372.   
  2373.   new_entry = (Ptr_Rolo_Entry) rolo_emalloc(sizeof(Rolo_Entry));
  2374.   
  2375.   /* copy the basic fields, but get a new timestamp */
  2376.   
  2377.   for (j = 0; j < N_BASIC_FIELDS - 1; j++) {
  2378.       set_basic_rolo_field(j,new_entry,copystr(get_basic_rolo_field(j,entry)));
  2379.   }
  2380.   set_basic_rolo_field(N_BASIC_FIELDS - 1,new_entry,timestring());
  2381.   
  2382.   /* copy the user-defined fields, if necessary */
  2383.   
  2384.   set_n_others(new_entry,n = get_n_others(entry));
  2385.   if (n > 0) {
  2386.      otherfields = (char **) rolo_emalloc(n * sizeof(char *));
  2387.      new_entry -> other_fields = otherfields;
  2388.      for (j = 0; j < n; j++) {  
  2389.          set_other_field(j,new_entry,copystr(get_other_field(j,entry)));
  2390.      }
  2391.   }     
  2392.   else new_entry -> other_fields = 0;     
  2393.      
  2394.   return(new_entry);     
  2395.      
  2396. }
  2397.  
  2398.  
  2399. rolo_update_mode (rlink) Ptr_Rolo_List rlink;
  2400.  
  2401. /* Update the fields of an entry.  The user is not allowed to modify the */
  2402. /* timestamp field. */
  2403.  
  2404. {
  2405.   int rval,menuval,findex,updated,newlen,n,nfields,j,name_changed;
  2406.   char *response,*s,*newfield,*newval,*other, **others;
  2407.   Ptr_Rolo_Entry entry,old_entry;
  2408.         
  2409.   cancel_update :
  2410.   
  2411.   entry = copy_entry(old_entry = get_entry(rlink));
  2412.  
  2413.   updated = 0;
  2414.   name_changed = 0;
  2415.   
  2416.   redisplay :
  2417.   
  2418.   display_entry_for_update(updated ? entry : old_entry);
  2419.   nfields = (N_BASIC_FIELDS - 1) + get_n_others(entry);
  2420.   
  2421.   reask :  
  2422.   
  2423.   cathelpfile(libdir("updatemenu"),0,0);  
  2424.   
  2425.   rval = menu_match (
  2426.        &menuval,&response,
  2427.        ": ",
  2428.        0,1,0,1,4,
  2429.        "\\",U_ABORT,
  2430.        "?",U_HELP,
  2431.        "Help",U_HELP,
  2432.        "",U_END_UPDATE
  2433.     );
  2434.     
  2435.   switch (rval) {    
  2436.     
  2437.     case MENU_MATCH :
  2438.   
  2439.       switch (menuval) {
  2440.  
  2441.         case U_HELP :
  2442.           cathelpfile(libdir("updatehelp"),"updating",1);
  2443.           any_char_to_continue();
  2444.           clear_the_screen();
  2445.           goto redisplay;
  2446.  
  2447.         case U_ABORT :
  2448.           if (updated) {
  2449.              printf("Previous updates to fields in this entry ignored\n");
  2450.           }
  2451.           return;
  2452.           break;
  2453.  
  2454.         case U_END_UPDATE :
  2455.           if (!updated) goto reask;
  2456.           display_entry(entry);
  2457.           if (MENU_YES == rolo_menu_yes_no (
  2458.                    "Confirm Update? ",DEFAULT_YES,1,
  2459.                    "confirmhelp","confirming update"
  2460.                 )) {
  2461.              printf("Update confirmed\n");
  2462.              sleep(1);
  2463.              set_entry(rlink,entry);
  2464.              if (name_changed) {
  2465.                 rolo_delete(rlink);
  2466.                 rolo_insert(rlink,compare_links);
  2467.              }
  2468.              changed = 1;
  2469.              return;
  2470.           }
  2471.           else {   
  2472.              printf("Updates ignored...\n");
  2473.              sleep(1);
  2474.              updated = 0;
  2475.              goto cancel_update;
  2476.           }
  2477.          break;
  2478.        
  2479.       }
  2480.       break;
  2481.      
  2482.     case MENU_NO_MATCH : 
  2483.  
  2484.       /* check that the response is an integer within range */
  2485.  
  2486.       findex = str_to_pos_int(response,1,nfields+1);
  2487.       if (findex < 0) {
  2488.          printf("Not a valid number...Please try again\n");
  2489.          goto reask;
  2490.       }
  2491.       findex--;
  2492.  
  2493.       /* we can either be updating a standard field or a user-defined field */
  2494.       /* or adding a new field */
  2495.  
  2496.       if (findex < N_BASIC_FIELDS - 1) {
  2497.          name_changed = (findex == 0);
  2498.          printf("Updating '%s'\n",Field_Names[findex]);
  2499.          printf("Old value: %s\n",get_basic_rolo_field(findex,entry));
  2500.          printf("New value: ");
  2501.          if (0 == (newval = copystr(get_new_value()))) break;
  2502.          set_basic_rolo_field(findex,entry,newval);
  2503.          updated = 1;
  2504.       }
  2505.       else if (findex != nfields) {
  2506.          findex -= N_BASIC_FIELDS - 1;
  2507.          printf("Updating \'");
  2508.          s = other = get_other_field(findex,entry);
  2509.          while (*s != ':') putc(*s++,stdout);
  2510.          printf("\' field\n");
  2511.          printf("Old value: %s\n",++s);
  2512.          printf("New value: ");
  2513.          if (0 == (newval = copystr(get_new_value()))) break;
  2514.          if (strlen(newval) == 0) {
  2515.             for (j = findex; j < get_n_others(entry); j++) {
  2516.                 set_other_field(j,entry,get_other_field(j+1,entry));
  2517.             }
  2518.             set_n_others(entry,get_n_others(entry) - 1);
  2519.          }
  2520.          else {   
  2521.             *s = '\0';
  2522.             newlen = strlen(other) + strlen(newval) + 2;
  2523.             newfield = rolo_emalloc(newlen);
  2524.             nbuffconcat(newfield,3,other," ",newval);
  2525.             set_other_field(findex,entry,newfield);
  2526.          }
  2527.          updated = 1;
  2528.       }
  2529.       else {
  2530.         loop:
  2531.         printf("New field (<name>: <value>): ");
  2532.         if (0 == (newfield = copystr(get_new_value()))) break;
  2533.         if (0 == index(newfield,':')) {
  2534.            fprintf(stderr,"No field name.  Use a ':'...\n");
  2535.            goto loop;
  2536.         }
  2537.         n = get_n_others(entry);
  2538.         set_n_others(entry,n + 1);
  2539.         others = (char **) rolo_emalloc((n + 1) * sizeof(char *));
  2540.         for (j = 0; j < n; j++) others[j] = get_other_field(j,entry);
  2541.         others[n] = newfield;
  2542.         entry -> other_fields = others;
  2543.         updated = 1;
  2544.       }
  2545.       break;
  2546.  
  2547.     case MENU_EOF :
  2548.       user_eof();
  2549.       break;
  2550.       
  2551.     default :      
  2552.       fprintf(stderr,"Impossible return from update menu_match\n");
  2553.       save_and_exit(-1);
  2554.       break;
  2555.      
  2556.   }
  2557.  
  2558.   goto redisplay;
  2559.  
  2560. }
  2561. SHAR_EOF
  2562. if test 6022 -ne "`wc -c < 'update.c'`"
  2563. then
  2564.     echo shar: error transmitting "'update.c'" '(should have been 6022 characters)'
  2565. fi
  2566. fi
  2567. exit 0
  2568. #    End of shell archive
  2569.